{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# PPO实现CarPole-v1（离散动作空间）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. 定义算法"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1 定义模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "class ActorSoftmax(nn.Module):\n",
    "    def __init__(self, input_dim, output_dim, hidden_dim=256):\n",
    "        super(ActorSoftmax, self).__init__()\n",
    "        self.fc1 = nn.Linear(input_dim, hidden_dim)\n",
    "        self.fc2 = nn.Linear(hidden_dim, hidden_dim)\n",
    "        self.fc3 = nn.Linear(hidden_dim, output_dim)\n",
    "    def forward(self,x):\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        probs = F.softmax(self.fc3(x),dim=1)\n",
    "        return probs\n",
    "class Critic(nn.Module):\n",
    "    def __init__(self,input_dim,output_dim,hidden_dim=256):\n",
    "        super(Critic,self).__init__()\n",
    "        assert output_dim == 1 # critic must output a single value\n",
    "        self.fc1 = nn.Linear(input_dim, hidden_dim)\n",
    "        self.fc2 = nn.Linear(hidden_dim, hidden_dim)\n",
    "        self.fc3 = nn.Linear(hidden_dim, output_dim)\n",
    "    def forward(self,x):\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        value = self.fc3(x)\n",
    "        return value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2 定义经验回放"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "from collections import deque\n",
    "class ReplayBufferQue:\n",
    "    '''DQN的经验回放池，每次采样batch_size个样本'''\n",
    "    def __init__(self, capacity: int) -> None:\n",
    "        self.capacity = capacity\n",
    "        self.buffer = deque(maxlen=self.capacity)\n",
    "    def push(self,transitions):\n",
    "        '''_summary_\n",
    "        Args:\n",
    "            trainsitions (tuple): _description_\n",
    "        '''\n",
    "        self.buffer.append(transitions)\n",
    "    def sample(self, batch_size: int, sequential: bool = False):\n",
    "        if batch_size > len(self.buffer):\n",
    "            batch_size = len(self.buffer)\n",
    "        if sequential: # sequential sampling\n",
    "            rand = random.randint(0, len(self.buffer) - batch_size)\n",
    "            batch = [self.buffer[i] for i in range(rand, rand + batch_size)]\n",
    "            return zip(*batch)\n",
    "        else:\n",
    "            batch = random.sample(self.buffer, batch_size)\n",
    "            return zip(*batch)\n",
    "    def clear(self):\n",
    "        self.buffer.clear()\n",
    "    def __len__(self):\n",
    "        return len(self.buffer)\n",
    "\n",
    "class PGReplay(ReplayBufferQue):\n",
    "    '''PG的经验回放池，每次采样所有样本，因此只需要继承ReplayBufferQue，重写sample方法即可\n",
    "    '''\n",
    "    def __init__(self):\n",
    "        self.buffer = deque()\n",
    "    def sample(self):\n",
    "        ''' sample all the transitions\n",
    "        '''\n",
    "        batch = list(self.buffer)\n",
    "        return zip(*batch)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.3 定义智能体"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "from torch.distributions import Categorical\n",
    "import numpy as np\n",
    "class Agent:\n",
    "    def __init__(self,cfg) -> None:\n",
    "        self.cfg = cfg\n",
    "        self.gamma = cfg.gamma\n",
    "        self.device = torch.device(cfg.device) \n",
    "        self.actor = ActorSoftmax(cfg.n_states,cfg.n_actions, hidden_dim = cfg.actor_hidden_dim).to(self.device)\n",
    "        self.critic = Critic(cfg.n_states,1,hidden_dim=cfg.critic_hidden_dim).to(self.device)\n",
    "        self.actor_optimizer = torch.optim.Adam(self.actor.parameters(), lr=cfg.actor_lr)\n",
    "        self.critic_optimizer = torch.optim.Adam(self.critic.parameters(), lr=cfg.critic_lr)\n",
    "        self.memory = PGReplay()\n",
    "        self.k_epochs = cfg.k_epochs # update policy for K epochs\n",
    "        self.eps_clip = cfg.eps_clip # clip parameter for PPO\n",
    "        self.entropy_coef = cfg.entropy_coef # entropy coefficient\n",
    "        self.sample_count = 0\n",
    "        self.batch_size = cfg.batch_size\n",
    "\n",
    "    def sample_action(self,state):\n",
    "        self.sample_count += 1\n",
    "        state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n",
    "        probs = self.actor(state)\n",
    "        dist = Categorical(probs)\n",
    "        action = dist.sample()\n",
    "        self.log_probs = dist.log_prob(action).detach()\n",
    "        return action.detach().cpu().numpy().item()\n",
    "    @torch.no_grad()\n",
    "    def predict_action(self,state):\n",
    "        state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n",
    "        probs = self.actor(state)\n",
    "        dist = Categorical(probs)\n",
    "        action = dist.sample()\n",
    "        return action.detach().cpu().numpy().item()\n",
    "    def update(self):\n",
    "        # update policy every n steps\n",
    "        if self.sample_count % self.batch_size != 0:\n",
    "            return\n",
    "        # print(\"update policy\")\n",
    "        old_states, old_actions, old_log_probs, old_rewards, old_dones = self.memory.sample()\n",
    "        # convert to tensor\n",
    "        old_states = torch.tensor(np.array(old_states), device=self.device, dtype=torch.float32)\n",
    "        old_actions = torch.tensor(np.array(old_actions), device=self.device, dtype=torch.float32)\n",
    "        old_log_probs = torch.tensor(old_log_probs, device=self.device, dtype=torch.float32).unsqueeze(dim=1)\n",
    "        # monte carlo estimate of state rewards\n",
    "        returns = []\n",
    "        discounted_sum = 0\n",
    "        for reward, done in zip(reversed(old_rewards), reversed(old_dones)):\n",
    "            if done:\n",
    "                discounted_sum = 0\n",
    "            discounted_sum = reward + (self.gamma * discounted_sum)\n",
    "            returns.insert(0, discounted_sum)\n",
    "        # Normalizing the rewards:\n",
    "        returns = torch.tensor(returns, device=self.device, dtype=torch.float32)\n",
    "        returns = (returns - returns.mean()) / (returns.std() + 1e-5) # 1e-5 to avoid division by zero\n",
    "        returns = returns.unsqueeze(dim=1)\n",
    "        torch_dataset = torch.utils.data.TensorDataset(old_states, old_actions, old_log_probs, returns)\n",
    "        loader = torch.utils.data.DataLoader(\n",
    "            dataset=torch_dataset,\n",
    "            batch_size=self.cfg.batch_size,\n",
    "            shuffle=False,\n",
    "        )\n",
    "        for _ in range(self.k_epochs):\n",
    "            # compute advantage\n",
    "            for old_states, old_actions, old_log_probs, returns in loader:\n",
    "                values = self.critic(old_states)\n",
    "                values = self.critic(old_states) # detach to avoid backprop through the critic\n",
    "                advantage = returns - values.detach()\n",
    "                # print(returns.shape,values.shape,advantage.shape)\n",
    "                # get action probabilities\n",
    "                probs = self.actor(old_states)\n",
    "                dist = Categorical(probs)\n",
    "                # get new action probabilities\n",
    "                new_probs = dist.log_prob(old_actions).unsqueeze(dim=1)\n",
    "                # compute ratio (pi_theta / pi_theta__old):\n",
    "                # old_log_probs = old_log_probs.sum(dim=1, keepdim=True)\n",
    "                # new_probs = new_probs.sum(dim=1, keepdim=True)\n",
    "                # print(new_probs,old_log_probs)\n",
    "                ratio = torch.exp(new_probs - old_log_probs) # old_log_probs must be detached\n",
    "\n",
    "                # print(new_probs.shape,old_log_probs.shape)\n",
    "                # compute surrogate loss\n",
    "                surr1 = ratio * advantage\n",
    "                surr2 = torch.clamp(ratio, 1 - self.eps_clip, 1 + self.eps_clip) * advantage\n",
    "                # compute actor loss\n",
    "                actor_loss = -torch.min(surr1, surr2).mean() + self.entropy_coef * dist.entropy().mean()\n",
    "                # compute critic loss\n",
    "                critic_loss = (returns - values).pow(2).mean()\n",
    "                # take gradient step\n",
    "                self.actor_optimizer.zero_grad()\n",
    "                self.critic_optimizer.zero_grad()\n",
    "                actor_loss.backward()\n",
    "                critic_loss.backward()\n",
    "                self.actor_optimizer.step()\n",
    "                self.critic_optimizer.step()\n",
    "        self.memory.clear()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. 定义训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "import copy\n",
    "def train(cfg, env, agent):\n",
    "    ''' 训练\n",
    "    '''\n",
    "    print(\"开始训练！\")\n",
    "    rewards = []  # 记录所有回合的奖励\n",
    "    steps = []\n",
    "    best_ep_reward = 0 # 记录最大回合奖励\n",
    "    output_agent = None\n",
    "    for i_ep in range(cfg.train_eps):\n",
    "        ep_reward = 0  # 记录一回合内的奖励\n",
    "        ep_step = 0\n",
    "        state, info = env.reset(seed = cfg.seed)  # 重置环境，返回初始状态\n",
    "        for _ in range(cfg.max_steps):\n",
    "            ep_step += 1\n",
    "            action = agent.sample_action(state)  # 选择动作\n",
    "            next_state, reward, terminated, truncated, info= env.step(action)  # 更新环境，返回transition\n",
    "            agent.memory.push((state, action,agent.log_probs,reward,terminated))  # 保存transition\n",
    "            state = next_state  # 更新下一个状态\n",
    "            agent.update()  # 更新智能体\n",
    "            ep_reward += reward  # 累加奖励\n",
    "            if terminated:\n",
    "                break\n",
    "        if (i_ep+1)%cfg.eval_per_episode == 0:\n",
    "            sum_eval_reward = 0\n",
    "            for _ in range(cfg.eval_eps):\n",
    "                eval_ep_reward = 0\n",
    "                state, info = env.reset()\n",
    "                for _ in range(cfg.max_steps):\n",
    "                    action = agent.predict_action(state)  # 选择动作\n",
    "                    next_state, reward, terminated, truncated, info= env.step(action)  # 更新环境，返回transition\n",
    "                    state = next_state  # 更新下一个状态\n",
    "                    eval_ep_reward += reward  # 累加奖励\n",
    "                    if terminated:\n",
    "                        break\n",
    "                sum_eval_reward += eval_ep_reward\n",
    "            mean_eval_reward = sum_eval_reward/cfg.eval_eps\n",
    "            if mean_eval_reward >= best_ep_reward:\n",
    "                best_ep_reward = mean_eval_reward\n",
    "                output_agent = copy.deepcopy(agent)\n",
    "                print(f\"回合：{i_ep+1}/{cfg.train_eps}，奖励：{ep_reward:.2f}，评估奖励：{mean_eval_reward:.2f}，最佳评估奖励：{best_ep_reward:.2f}，更新模型！\")\n",
    "            else:\n",
    "                print(f\"回合：{i_ep+1}/{cfg.train_eps}，奖励：{ep_reward:.2f}，评估奖励：{mean_eval_reward:.2f}，最佳评估奖励：{best_ep_reward:.2f}\")\n",
    "        steps.append(ep_step)\n",
    "        rewards.append(ep_reward)\n",
    "    print(\"完成训练！\")\n",
    "    env.close()\n",
    "    return output_agent,{'rewards':rewards}\n",
    "\n",
    "def test(cfg, env, agent):\n",
    "    print(\"开始测试！\")\n",
    "    rewards = []  # 记录所有回合的奖励\n",
    "    steps = []\n",
    "    for i_ep in range(cfg.test_eps):\n",
    "        ep_reward = 0  # 记录一回合内的奖励\n",
    "        ep_step = 0\n",
    "        state, info = env.reset(seed = cfg.seed)  # 重置环境，返回初始状态\n",
    "        for _ in range(cfg.max_steps):\n",
    "            ep_step+=1\n",
    "            action = agent.predict_action(state)  # 选择动作\n",
    "            next_state, reward, terminated, truncated, info= env.step(action)  # 更新环境，返回transition\n",
    "            state = next_state  # 更新下一个状态\n",
    "            ep_reward += reward  # 累加奖励\n",
    "            if terminated:\n",
    "                break\n",
    "        steps.append(ep_step)\n",
    "        rewards.append(ep_reward)\n",
    "        print(f\"回合：{i_ep+1}/{cfg.test_eps}，奖励：{ep_reward:.2f}\")\n",
    "    print(\"完成测试\")\n",
    "    env.close()\n",
    "    return {'rewards':rewards}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. 定义环境"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "import gymnasium  as gym\n",
    "import os\n",
    "import numpy as np\n",
    "def all_seed(env,seed = 1):\n",
    "    ''' 万能的seed函数\n",
    "    '''\n",
    "    if seed == 0:\n",
    "        return\n",
    "    np.random.seed(seed)\n",
    "    random.seed(seed)\n",
    "    torch.manual_seed(seed) # config for CPU\n",
    "    torch.cuda.manual_seed(seed) # config for GPU\n",
    "    os.environ['PYTHONHASHSEED'] = str(seed) # config for python scripts\n",
    "    # config for cudnn\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "    torch.backends.cudnn.enabled = False\n",
    "def env_agent_config(cfg):\n",
    "    env = gym.make(cfg.env_name) # 创建环境\n",
    "    all_seed(env,seed=cfg.seed)\n",
    "    n_states = env.observation_space.shape[0]\n",
    "    n_actions = env.action_space.n\n",
    "    print(f\"状态空间维度：{n_states}，动作空间维度：{n_actions}\")\n",
    "    # 更新n_states和n_actions到cfg参数中\n",
    "    setattr(cfg, 'n_states', n_states)\n",
    "    setattr(cfg, 'n_actions', n_actions) \n",
    "    agent = Agent(cfg)\n",
    "    return env,agent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. 设置参数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "class Config:\n",
    "    def __init__(self) -> None:\n",
    "        self.env_name = \"CartPole-v1\" # 环境名字\n",
    "        self.new_step_api = False # 是否用gym的新api\n",
    "        self.algo_name = \"PPO\" # 算法名字\n",
    "        self.mode = \"train\" # train or test\n",
    "        self.seed = 1 # 随机种子\n",
    "        self.device = \"cpu\" # device to use\n",
    "        self.train_eps = 200 # 训练的回合数\n",
    "        self.test_eps = 20 # 测试的回合数\n",
    "        self.max_steps = 200 # 每个回合的最大步数\n",
    "        self.eval_eps = 5 # 评估的回合数\n",
    "        self.eval_per_episode = 10 # 评估的频率\n",
    "\n",
    "        self.gamma = 0.99 # 折扣因子\n",
    "        self.k_epochs = 6 # 更新策略网络的次数\n",
    "        self.actor_lr = 0.0003 # actor网络的学习率\n",
    "        self.critic_lr = 0.001 # critic网络的学习率\n",
    "        self.eps_clip = 0.2 # epsilon-clip\n",
    "        self.entropy_coef = 0.01 # entropy的系数\n",
    "        self.batch_size = 256 # 更新频率\n",
    "        self.sgd_batch_size = 128\n",
    "        self.actor_hidden_dim = 256 # actor网络的隐藏层维度\n",
    "        self.critic_hidden_dim = 256 # critic网络的隐藏层维度\n",
    "\n",
    "def smooth(data, weight=0.9):  \n",
    "    '''用于平滑曲线，类似于Tensorboard中的smooth曲线\n",
    "    '''\n",
    "    last = data[0] \n",
    "    smoothed = []\n",
    "    for point in data:\n",
    "        smoothed_val = last * weight + (1 - weight) * point  # 计算平滑值\n",
    "        smoothed.append(smoothed_val)                    \n",
    "        last = smoothed_val                                \n",
    "    return smoothed\n",
    "\n",
    "def plot_rewards(rewards,cfg, tag='train'):\n",
    "    ''' 画图\n",
    "    '''\n",
    "    sns.set()\n",
    "    plt.figure()  # 创建一个图形实例，方便同时多画几个图\n",
    "    plt.title(f\"{tag}ing curve on {cfg.device} of {cfg.algo_name} for {cfg.env_name}\")\n",
    "    plt.xlabel('epsiodes')\n",
    "    plt.plot(rewards, label='rewards')\n",
    "    plt.plot(smooth(rewards), label='smoothed')\n",
    "    plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. 开始训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "状态空间维度：4，动作空间维度：2\n",
      "开始训练！\n",
      "回合：10/200，奖励：12.00，评估奖励：28.20，最佳评估奖励：28.20，更新模型！\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "回合：20/200，奖励：16.00，评估奖励：25.60，最佳评估奖励：28.20\n",
      "回合：30/200，奖励：26.00，评估奖励：27.40，最佳评估奖励：28.20\n",
      "回合：40/200，奖励：24.00，评估奖励：51.60，最佳评估奖励：51.60，更新模型！\n",
      "回合：50/200，奖励：65.00，评估奖励：62.80，最佳评估奖励：62.80，更新模型！\n",
      "回合：60/200，奖励：20.00，评估奖励：63.80，最佳评估奖励：63.80，更新模型！\n",
      "回合：70/200，奖励：34.00，评估奖励：86.80，最佳评估奖励：86.80，更新模型！\n",
      "回合：80/200，奖励：95.00，评估奖励：80.60，最佳评估奖励：86.80\n",
      "回合：90/200，奖励：200.00，评估奖励：114.80，最佳评估奖励：114.80，更新模型！\n",
      "回合：100/200，奖励：183.00，评估奖励：142.00，最佳评估奖励：142.00，更新模型！\n",
      "回合：110/200，奖励：50.00，评估奖励：111.60，最佳评估奖励：142.00\n",
      "回合：120/200，奖励：200.00，评估奖励：172.20，最佳评估奖励：172.20，更新模型！\n",
      "回合：130/200，奖励：183.00，评估奖励：113.40，最佳评估奖励：172.20\n",
      "回合：140/200，奖励：166.00，评估奖励：200.00，最佳评估奖励：200.00，更新模型！\n",
      "回合：150/200，奖励：200.00，评估奖励：195.20，最佳评估奖励：200.00\n",
      "回合：160/200，奖励：200.00，评估奖励：177.60，最佳评估奖励：200.00\n",
      "回合：170/200，奖励：129.00，评估奖励：93.40，最佳评估奖励：200.00\n",
      "回合：180/200，奖励：136.00，评估奖励：120.00，最佳评估奖励：200.00\n",
      "回合：190/200，奖励：200.00，评估奖励：193.00，最佳评估奖励：200.00\n",
      "回合：200/200，奖励：200.00，评估奖励：200.00，最佳评估奖励：200.00，更新模型！\n",
      "完成训练！\n",
      "开始测试！\n",
      "回合：1/20，奖励：200.00\n",
      "回合：2/20，奖励：200.00\n",
      "回合：3/20，奖励：200.00\n",
      "回合：4/20，奖励：200.00\n",
      "回合：5/20，奖励：200.00\n",
      "回合：6/20，奖励：200.00\n",
      "回合：7/20，奖励：200.00\n",
      "回合：8/20，奖励：200.00\n",
      "回合：9/20，奖励：200.00\n",
      "回合：10/20，奖励：200.00\n",
      "回合：11/20，奖励：200.00\n",
      "回合：12/20，奖励：200.00\n",
      "回合：13/20，奖励：200.00\n",
      "回合：14/20，奖励：200.00\n",
      "回合：15/20，奖励：200.00\n",
      "回合：16/20，奖励：200.00\n",
      "回合：17/20，奖励：200.00\n",
      "回合：18/20，奖励：200.00\n",
      "回合：19/20，奖励：200.00\n",
      "回合：20/20，奖励：200.00\n",
      "完成测试\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 获取参数\n",
    "cfg = Config() \n",
    "# 训练\n",
    "env, agent = env_agent_config(cfg)\n",
    "best_agent,res_dic = train(cfg, env, agent)\n",
    " \n",
    "plot_rewards(res_dic['rewards'], cfg, tag=\"train\")  \n",
    "# 测试\n",
    "res_dic = test(cfg, env, best_agent)\n",
    "plot_rewards(res_dic['rewards'], cfg, tag=\"test\")  # 画出结果"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.7.12 ('easyrl')",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.18"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "f5a9629e9f3b9957bf68a43815f911e93447d47b3d065b6a8a04975e44c504d9"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
